﻿#region License
// Copyright 2007-2008 Rory Plaire (codekaizen@gmail.com)
/*
 * This license governs use of the accompanying software. If you use the software, you
 * accept this license. If you do not accept the license, do not use the software.
 * 
 * 1. Definitions
 * The terms "reproduce," "reproduction," "derivative works," and "distribution" have the
 * same meaning here as under U.S. copyright law.
 * A "contribution" is the original software, or any additions or changes to the software.
 * A "contributor" is any person that distributes its contribution under this license.
 * "Licensed patents" are a contributor's patent claims that read directly on its contribution.
 * 
 * 2. Grant of Rights
 * (A) Copyright Grant- Subject to the terms of this license, including the license conditions 
 *     and limitations in section 3, each contributor grants you a non-exclusive, worldwide, 
 *     royalty-free copyright license to reproduce its contribution, prepare derivative works 
 *     of its contribution, and distribute its contribution or any derivative works that you create.
 * (B) Patent Grant- Subject to the terms of this license, including the license conditions and 
 *     limitations in section 3, each contributor grants you a non-exclusive, worldwide, royalty-free 
 *     license under its licensed patents to make, have made, use, sell, offer for sale, import, 
 *     and/or otherwise dispose of its contribution in the software or derivative works of the 
 *     contribution in the software.
 * 
 * 3. Conditions and Limitations
 * (A) No Trademark License- This license does not grant you rights to use any contributors' 
 *     name, logo, or trademarks.
 * (B) If you bring a patent claim against any contributor over patents that you claim are 
 *     infringed by the software, your patent license from such contributor to the software 
 *     ends automatically.
 * (C) If you distribute any portion of the software, you must retain all copyright, patent, 
 *     trademark, and attribution notices that are present in the software.
 * (D) If you distribute any portion of the software in source code form, you may do so only under 
 *     this license by including a complete copy of this license with your distribution. If you 
 *     distribute any portion of the software in compiled or object code form, you may only do so 
 *     under a license that complies with this license.
 * (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no 
 *     express warranties, guarantees or conditions. You may have additional consumer rights under 
 *     your local laws which this license cannot change. To the extent permitted under your local laws, 
 *     the contributors exclude the implied warranties of merchantability, fitness for a particular 
 *     purpose and non-infringement.
 * 
 */
#endregion

using System;
using System.Collections.Generic;
using NPack.Numeric.Interfaces;

namespace NPack.Matrix
{
    public class LinearFactory<TComponent> : ILinearFactory<TComponent, Vector<TComponent>, Matrix<TComponent>>,
                                             ILinearFactory<TComponent>
        //where TComponent : IEquatable<TComponent>, IComparable<TComponent>,
        //                   IConvertible, IFormattable,
        //                   IComputable<Double, TComponent>
    {
        #region IMatrixFactory<TComponent,Matrix<TComponent>> Members

        public Matrix<TComponent> CreateMatrix(Matrix<TComponent> matrix)
        {
            return new Matrix<TComponent>(matrix);
        }

        public Matrix<TComponent> CreateMatrix(Int32 rowCount, Int32 columnCount)
        {
            return CreateMatrix(MatrixFormat.ColumnMajor, rowCount, columnCount);
        }

        IMatrix<TComponent> IMatrixFactory<TComponent>.CreateMatrix(int rowCount, int columnCount, IEnumerable<TComponent> values)
        {
            throw new System.NotImplementedException();
        }

        IMatrix<TComponent> IMatrixFactory<TComponent>.CreateMatrix(MatrixFormat format, int rowCount, int columnCount)
        {
            throw new System.NotImplementedException();
        }

        public IMatrix<TComponent> CreateMatrix(IMatrix<TComponent> matrix)
        {
            throw new System.NotImplementedException();
        }

        public ITransformMatrix<TComponent> CreateTransformMatrix(int rowCount, int columnCount)
        {
            throw new System.NotImplementedException();
        }

        public ITransformMatrix<TComponent> CreateTransformMatrix(MatrixFormat format, int rowCount, int columnCount)
        {
            throw new System.NotImplementedException();
        }

        public IAffineTransformMatrix<TComponent> CreateAffineMatrix(int rank)
        {
            return CreateAffineMatrix(MatrixFormat.ColumnMajor, rank);
        }

        public IAffineTransformMatrix<TComponent> CreateAffineMatrix(MatrixFormat format, int rank)
        {
            return new AffineTransformMatrix<TComponent>(format, rank);
        }

        IMatrix<TComponent> IMatrixFactory<TComponent>.CreateMatrix(int rowCount, int columnCount)
        {
            throw new System.NotImplementedException();
        }

        public Matrix<TComponent> CreateMatrix(Int32 rowCount, Int32 columnCount, IEnumerable<TComponent> values)
        {
            throw new NotImplementedException();
        }

        public Matrix<TComponent> CreateMatrix(MatrixFormat format, Int32 rowCount, Int32 columnCount)
        {
            return new Matrix<TComponent>(format, rowCount, columnCount);
        }

        #endregion

        #region IVectorFactory<T,IVector<T>> Members

        public Vector<TComponent> CreateVector(Int32 componentCount)
        {
            return new Vector<TComponent>(componentCount);
        }

        IVector<TComponent> IVectorFactory<TComponent>.CreateVector(IEnumerable<TComponent> values)
        {
            throw new System.NotImplementedException();
        }

        IVector<TComponent> IVectorFactory<TComponent>.CreateVector(TComponent a, TComponent b)
        {
            throw new System.NotImplementedException();
        }

        IVector<TComponent> IVectorFactory<TComponent>.CreateVector(TComponent a, TComponent b, TComponent c)
        {
            throw new System.NotImplementedException();
        }

        IVector<TComponent> IVectorFactory<TComponent>.CreateVector(params TComponent[] components)
        {
            throw new System.NotImplementedException();
        }

        IVector<TComponent> IVectorFactory<TComponent>.CreateVector(double a, double b)
        {
            throw new System.NotImplementedException();
        }

        IVector<TComponent> IVectorFactory<TComponent>.CreateVector(double a, double b, double c)
        {
            throw new System.NotImplementedException();
        }

        IVector<TComponent> IVectorFactory<TComponent>.CreateVector(params double[] components)
        {
            throw new System.NotImplementedException();
        }

        IVector<TComponent> IVectorFactory<TComponent>.CreateVector(int componentCount)
        {
            throw new System.NotImplementedException();
        }

        public Vector<TComponent> CreateVector(IEnumerable<TComponent> values)
        {
            TComponent[] components = new List<TComponent>(values).ToArray();
            return new Vector<TComponent>(components);
        }

        #endregion

        #region IVectorFactory<TComponent,Vector<TComponent>> Members


        public Vector<TComponent> CreateVector(TComponent a, TComponent b)
        {
            throw new NotImplementedException();
        }

        public Vector<TComponent> CreateVector(TComponent a, TComponent b, TComponent c)
        {
            throw new NotImplementedException();
        }

        public Vector<TComponent> CreateVector(params TComponent[] components)
        {
            throw new NotImplementedException();
        }

        public Vector<TComponent> CreateVector(Double a, Double b)
        {
            throw new NotImplementedException();
        }

        public Vector<TComponent> CreateVector(Double a, Double b, Double c)
        {
            throw new NotImplementedException();
        }

        public Vector<TComponent> CreateVector(params Double[] components)
        {
            throw new NotImplementedException();
        }

        #endregion
    }
}